package edu.client;

import java.util.LinkedList;
import java.util.List;

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.BlurEvent;
import com.google.gwt.event.dom.client.BlurHandler;
import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ChangeHandler;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.HTMLTable.Cell;
import com.google.gwt.user.client.ui.HasHorizontalAlignment;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.LayoutPanel;
import com.google.gwt.user.client.ui.ListBox;
import com.google.gwt.user.client.ui.ScrollPanel;
import com.google.gwt.user.client.ui.TabPanel;
import com.google.gwt.user.client.ui.TextBox;

import edu.client.ComprasService.ComprasService;
import edu.client.ComprasService.ComprasServiceAsync;
import edu.client.IngenieriaService.IngenieriaService;
import edu.client.IngenieriaService.IngenieriaServiceAsync;
import edu.shared.DTO.ClaseProductoDTO;
import edu.shared.DTO.ElementoProductoDTO;
import edu.shared.DTO.MaterialProductoDTO;
import edu.shared.DTO.MedidaFijaProductoDTO;
import edu.shared.DTO.MedidaVariableEstandarDTO;
import edu.shared.DTO.ProductoDTO;
import edu.shared.DTO.ProveedorDTO;

public class P_CrearProducto extends Composite{
	
	private ListBox cbCodigoClase;
	private TextBox tbNombreClase;
	
	private ListBox cbCodigoElemento;
	private TextBox tbNombreElemento;
	
	private ListBox cbCodigoMaterial;
	private TextBox tbNombreMaterial;
	
	private TextBox tbMedidaFija;
	private ListBox cbDimension;
	private TextBox tbMedidaVariable1;
	private TextBox tbMedidaVariable2;
	
	private FlexTable ftMedidas;
	
	//columnas para la tabla dimensiones
	private static final int COL_MEDIDA_1 = 0;
	private static final int COL_MEDIDA_2 = 1;
	private static final int COL_ELIMINAR_MEDIDA = 2;
		
	private ListBox cbProveedor;
	
	private FlexTable ftProveedores;
	
	//columnas para la tabla proveedores
	private static final int COL_NOMBRE = 0;
	private static final int COL_RUBRO = 1;
	private static final int COL_TELEFONO = 2;
	private static final int COL_MAIL = 3;
	private static final int COL_MAS_INFO = 4;
	private static final int COL_ELIMINAR_PROVEEDOR = 5;
	
	private TabPanel tbPadre;
	private IngenieriaServiceAsync ingenieriaService;
	private List<ClaseProductoDTO> clasesProducto;
	private List<ElementoProductoDTO> elementosProducto;
	private List<MaterialProductoDTO> materialesProducto;
	private List<String> nombresProveedores;
	private List<MedidaVariableEstandarDTO> medidas;
	private List<ProveedorDTO> proveedores;
	
	private Button btnCrearProducto;
	
	public P_CrearProducto(TabPanel padre) {
		
		tbPadre = padre;
		ingenieriaService = GWT.create(IngenieriaService.class);
		proveedores = new LinkedList<ProveedorDTO>();
		medidas = new LinkedList<MedidaVariableEstandarDTO>();
		
		LayoutPanel layoutPanel = new LayoutPanel();
		initWidget(layoutPanel);
		layoutPanel.setSize((Window.getClientWidth() - 55) + "px", "1350px");

		Label lblClaseProducto = new Label("CLASE DE PRODUCTO");
		lblClaseProducto.setStyleName("labelTitulo");
		layoutPanel.add(lblClaseProducto);
		layoutPanel.setWidgetLeftWidth(lblClaseProducto, 2.5, Unit.PCT, 95.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblClaseProducto, 15.0, Unit.PX, 50.0, Unit.PX);
		
		Label lblCodigoClase = new Label("CÓDIGO DE CLASE:");
		lblCodigoClase.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblCodigoClase);
		layoutPanel.setWidgetLeftWidth(lblCodigoClase, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblCodigoClase, 85.0, Unit.PX, 19.0, Unit.PX);
		
		cbCodigoClase = new ListBox();
		
		//cuando el combobox del código de clase de producto cambia de ítem
		cbCodigoClase.addChangeHandler(new ChangeHandler() {
			public void onChange(ChangeEvent event) {
				
				int itemSeleccionado = cbCodigoClase.getSelectedIndex();
				
				if(itemSeleccionado == 0)
					tbNombreClase.setEnabled(true);
				
				else
					tbNombreClase.setEnabled(false);
				
				
				//inicializamos el combobox de dimensiones para que el usuario elija
				cbDimension.setSelectedIndex(0);
				cbDimension.setEnabled(true);
				
				//obtenemos la clase seleccionada en el combobox
				ClaseProductoDTO claseSeleccionada = clasesProducto.get(itemSeleccionado);
				
				//completamos el textbox nombre de clase con el nombre de la clase seleccionada
				tbNombreClase.setText(claseSeleccionada.getNombre());
				
				//borramos las medidas cargadas
				tbMedidaVariable1.setText("");
				tbMedidaVariable2.setText("");
				ftMedidas.clear();
				medidas.clear();
				
				cargarComboElemento();
			}
		});
		
		layoutPanel.add(cbCodigoClase);
		layoutPanel.setWidgetLeftWidth(cbCodigoClase, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(cbCodigoClase, 80.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblNombreClase = new Label("NOMBRE DE CLASE:");
		lblNombreClase.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblNombreClase);
		layoutPanel.setWidgetLeftWidth(lblNombreClase, 50.0, Unit.PCT, 19.8, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblNombreClase, 85.0, Unit.PX, 19.0, Unit.PX);
		
		tbNombreClase = new TextBox();
		
		//cuando se pierde el foco en el campo de texto nombre de clase
		tbNombreClase.addBlurHandler(new BlurHandler() {
			public void onBlur(BlurEvent event) {
				
				//recuperamos el nombre de clase que ingresó el usuario y se lo seteamos a la nueva clase
				String nombreClase = tbNombreClase.getText();				
				clasesProducto.get(0).setNombre(nombreClase);
			}
		});
		
		
		layoutPanel.add(tbNombreClase);
		layoutPanel.setWidgetLeftWidth(tbNombreClase, 70.0, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbNombreClase, 80.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblElementoProducto = new Label("ELEMENTO DE PRODUCTO");
		lblElementoProducto.setStyleName("labelTitulo");
		layoutPanel.add(lblElementoProducto);
		layoutPanel.setWidgetLeftWidth(lblElementoProducto, 2.5, Unit.PCT, 95.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblElementoProducto, 135.0, Unit.PX, 50.0, Unit.PX);
		
		Label lblCodigoElemento = new Label("CÓDIGO DE ELEMENTO:");
		lblCodigoElemento.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblCodigoElemento);
		layoutPanel.setWidgetLeftWidth(lblCodigoElemento, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblCodigoElemento, 205.0, Unit.PX, 19.0, Unit.PX);
		
		cbCodigoElemento = new ListBox();
		
		//cuando el combobox de código de elemento de producto cambia de item
		cbCodigoElemento.addChangeHandler(new ChangeHandler() {
			public void onChange(ChangeEvent event) {
				
				int itemSeleccionado = cbCodigoElemento.getSelectedIndex();
				
				//obtenemos el elemento seleccionado
				ElementoProductoDTO elementoSeleccionado = elementosProducto.get(itemSeleccionado);
				
				//si se seleecionó el item de nuevo elemento
				if(itemSeleccionado == 0){
					tbNombreElemento.setEnabled(true);
					
					//inicializamos el combobox de dimensiones para que el usuario elija
					cbDimension.setSelectedIndex(0);
					cbDimension.setEnabled(true);
				}
				
				
				//si se seleccionó un elemento existente
				else{
					tbNombreElemento.setEnabled(false);
					
					cbDimension.setEnabled(false);
				}
								
				//seleccionamos el radio buton correspondiente a la dimensión del elemento
				if(elementoSeleccionado.getTipoDimension().equals("UNIDAD")){
					cbDimension.setSelectedIndex(0);
					
					//se deshabilita la medida 2 y se limpia su contenido
					tbMedidaVariable2.setEnabled(false);
				}
				else if(elementoSeleccionado.getTipoDimension().equals("LONGITUD")){
					cbDimension.setSelectedIndex(1);
				
					//se deshabilita la medida 2 y se limpia su contenido
					tbMedidaVariable2.setEnabled(false);
				}
				else if(elementoSeleccionado.getTipoDimension().equals("SUPERFICIE")){
					cbDimension.setSelectedIndex(2);
				
					//se habilita la medida 2
					tbMedidaVariable2.setEnabled(true);
				}
				
				//cargamos el nombre del elemento
				tbNombreElemento.setText(elementoSeleccionado.getNombre());
				
				//borramos las medidas cargadas
				tbMedidaVariable1.setText("");
				tbMedidaVariable2.setText("");
				ftMedidas.clear();
				medidas.clear();
			}
		});
		
		layoutPanel.add(cbCodigoElemento);
		layoutPanel.setWidgetLeftWidth(cbCodigoElemento, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(cbCodigoElemento, 200.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblNombreElemento = new Label("NOMBRE DE ELEMENTO:");
		lblNombreElemento.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblNombreElemento);
		layoutPanel.setWidgetLeftWidth(lblNombreElemento, 50.0, Unit.PCT, 19.8, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblNombreElemento, 205.0, Unit.PX, 19.0, Unit.PX);
		
		tbNombreElemento = new TextBox();
		
		//cuando se pierde el foco en el campo de texto nombre de elemento
		tbNombreElemento.addBlurHandler(new BlurHandler() {
			public void onBlur(BlurEvent event) {
				
				//recuperamos el nombre de producto que ingresó el usuario y se lo seteamos al nuevo producto
				String nombreElemento = tbNombreElemento.getText();				
				elementosProducto.get(0).setNombre(nombreElemento);
			}
		});
		
		layoutPanel.add(tbNombreElemento);
		layoutPanel.setWidgetLeftWidth(tbNombreElemento, 70.0, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbNombreElemento, 200.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblMaterialProducto = new Label("MATERIAL DE PRODUCTO");
		lblMaterialProducto.setStyleName("labelTitulo");
		layoutPanel.add(lblMaterialProducto);
		layoutPanel.setWidgetLeftWidth(lblMaterialProducto, 2.5, Unit.PCT, 95.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblMaterialProducto, 255.0, Unit.PX, 50.0, Unit.PX);
		
		Label lblCodigoMaterial = new Label("CÓDIGO DE MATERIAL:");
		lblCodigoMaterial.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblCodigoMaterial);
		layoutPanel.setWidgetLeftWidth(lblCodigoMaterial, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblCodigoMaterial, 325.0, Unit.PX, 19.0, Unit.PX);
		
		cbCodigoMaterial = new ListBox();
		
		//cuando el combobox de códigos de material cambia de item
		cbCodigoMaterial.addChangeHandler(new ChangeHandler() {
			public void onChange(ChangeEvent event) {
				
				//recuperamos el item seleccionado en el combobox de codigos de materiales
				int itemSeleccionado = cbCodigoMaterial.getSelectedIndex();
				
				if(itemSeleccionado == 0)
					tbNombreMaterial.setEnabled(true);
				
				else
					tbNombreMaterial.setEnabled(false);
				
				//recuperamos el material seleccionado de la lista de materiales
				MaterialProductoDTO materialSeleccionado = materialesProducto.get(itemSeleccionado);
				
				//seteamos el nombre del material seleccionado al textbox nombre de material
				tbNombreMaterial.setText(materialSeleccionado.getNombre());			
			}
		});
		
		layoutPanel.add(cbCodigoMaterial);
		layoutPanel.setWidgetLeftWidth(cbCodigoMaterial, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(cbCodigoMaterial, 320.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblNombreMaterial = new Label("NOMBRE DE MATERIAL:");
		lblNombreMaterial.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblNombreMaterial);
		layoutPanel.setWidgetLeftWidth(lblNombreMaterial, 50.0, Unit.PCT, 19.8, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblNombreMaterial, 325.0, Unit.PX, 19.0, Unit.PX);
		
		tbNombreMaterial = new TextBox();
		
		//cuando se pierde el foco en el campo de texto nombre de material
		tbNombreMaterial.addBlurHandler(new BlurHandler() {
			public void onBlur(BlurEvent event) {
				
				//recuperamos el nombre del material que ingresó el usuario y se lo seteamos al nuevo producto
				String nombreMaterial = tbNombreMaterial.getText();				
				materialesProducto.get(0).setNombre(nombreMaterial);
			}
		});
				
		layoutPanel.add(tbNombreMaterial);
		layoutPanel.setWidgetLeftWidth(tbNombreMaterial, 70.0, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbNombreMaterial, 320.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblMedidaProducto = new Label("MEDIDAS DEL PRODUCTO");
		lblMedidaProducto.setStyleName("labelTitulo");
		layoutPanel.add(lblMedidaProducto);
		layoutPanel.setWidgetLeftWidth(lblMedidaProducto, 2.5, Unit.PCT, 95.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblMedidaProducto, 375.0, Unit.PX, 50.0, Unit.PX);
		
		Label lblMedidaFija = new Label("MEDIDA FIJA:");
		lblMedidaFija.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblMedidaFija);
		layoutPanel.setWidgetLeftWidth(lblMedidaFija, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblMedidaFija, 450.0, Unit.PX, 19.0, Unit.PX);
		
		tbMedidaFija = new TextBox();
		layoutPanel.add(tbMedidaFija);
		layoutPanel.setWidgetLeftWidth(tbMedidaFija, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbMedidaFija, 445.0, Unit.PX, 32.0, Unit.PX);
		
		Label lblDimesion = new Label("DIMENSIÓN MEDIDA VARIABLE:");
		lblDimesion.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblDimesion);
		layoutPanel.setWidgetLeftWidth(lblDimesion, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblDimesion, 500.0, Unit.PX, 19.0, Unit.PX);
		
		cbDimension = new ListBox();
		
		//cuando el combobox de dimensiones cambia de item
		cbDimension.addChangeHandler(new ChangeHandler() {
			public void onChange(ChangeEvent event) {
				
				//si se seleccionó "SUPERFICIE"
				if(cbDimension.getValue(cbDimension.getSelectedIndex()).equals("SUPERFICIE"))
					tbMedidaVariable2.setEnabled(true);
				
				else
					tbMedidaVariable2.setEnabled(false);
			}
		});
		layoutPanel.add(cbDimension);
		layoutPanel.setWidgetLeftWidth(cbDimension, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(cbDimension, 495.0, Unit.PX, 32.0, Unit.PX);

		Label lblMedidaVariable = new Label("MEDIDA VARIABLE:");
		lblMedidaVariable.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblMedidaVariable);
		layoutPanel.setWidgetLeftWidth(lblMedidaVariable, 50.0, Unit.PCT, 19.8, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblMedidaVariable, 500.0, Unit.PX, 19.0, Unit.PX);
		
		tbMedidaVariable1 = new TextBox();
		layoutPanel.add(tbMedidaVariable1);
		layoutPanel.setWidgetLeftWidth(tbMedidaVariable1, 70.0, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbMedidaVariable1, 495.0, Unit.PX, 32.0, Unit.PX);
		
		Label porLb = new Label("X");
		porLb.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
		layoutPanel.add(porLb);
		layoutPanel.setWidgetLeftWidth(porLb, 80.0, Unit.PCT, 5.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(porLb, 500.0, Unit.PX, 19.0, Unit.PX);
		
		tbMedidaVariable2 = new TextBox();
		layoutPanel.add(tbMedidaVariable2);
		layoutPanel.setWidgetLeftWidth(tbMedidaVariable2, 85.0, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(tbMedidaVariable2, 496.0, Unit.PX, 32.0, Unit.PX);

		Button btnAgregarMedida = new Button("");
		
		//cuando se presiona el botón agregar
		btnAgregarMedida.addClickHandler(new ClickHandler() {
			public void onClick(ClickEvent event) {
				cargarMedidaATabla();
			}
		});
		btnAgregarMedida.setText("AGREGAR");
		layoutPanel.add(btnAgregarMedida);
		layoutPanel.setWidgetLeftWidth(btnAgregarMedida, 45.0, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(btnAgregarMedida, 540.0, Unit.PX, 28.0, Unit.PX);
		
		ScrollPanel spMedidas = new ScrollPanel();
		spMedidas.setStyleName("tabla");
		layoutPanel.add(spMedidas);
		layoutPanel.setWidgetLeftWidth(spMedidas, 5.0, Unit.PCT, 90.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(spMedidas, 570.0, Unit.PX, 250.0, Unit.PX);
		
		ftMedidas = new FlexTable();
		spMedidas.setWidget(ftMedidas);
		ftMedidas.setSize("100%", "100%");
		
		//cargamos el encabezado de la tabla
		// columna medida variable 1
		ftMedidas.setText(0, COL_MEDIDA_1, "MEDIDA VARIABLE 1");
		ftMedidas.getCellFormatter().setWidth(0, COL_MEDIDA_1, "47.5%");
		
		// columna medida variable 2
		ftMedidas.setText(0, COL_MEDIDA_2, "MEDIDA VARIABLE 2");
		ftMedidas.getCellFormatter().setWidth(0, COL_MEDIDA_2, "47.5%");
						
		// columna eliminar
		ftMedidas.setText(0, COL_ELIMINAR_MEDIDA, "");
		ftMedidas.getCellFormatter().setWidth(0, COL_ELIMINAR_MEDIDA, "5%");
		
		// seteamos el estilo a los encabezados
		ftMedidas.getRowFormatter().addStyleName(0, "tablaEncabezado");
		
		
		Label lblProveedores = new Label("PROVEEDORES");
		lblProveedores.setStyleName("labelTitulo");
		layoutPanel.add(lblProveedores);
		layoutPanel.setWidgetLeftWidth(lblProveedores, 2.5, Unit.PCT, 95.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblProveedores, 830.0, Unit.PX, 50.0, Unit.PX);
		
		Label lblProveedor = new Label("PROVEEDOR:");
		lblProveedor.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		layoutPanel.add(lblProveedor);
		layoutPanel.setWidgetLeftWidth(lblProveedor, 0.0, Unit.PCT, 17.3, Unit.PCT);
		layoutPanel.setWidgetTopHeight(lblProveedor, 905.0, Unit.PX, 19.0, Unit.PX);
		
		cbProveedor = new ListBox();
		layoutPanel.add(cbProveedor);
		layoutPanel.setWidgetLeftWidth(cbProveedor, 17.5, Unit.PCT, 25.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(cbProveedor, 900.0, Unit.PX, 32.0, Unit.PX);
		
		//al presionar el botón agregar
		Button btnAgregarProveedor = new Button("AGREGAR");
		btnAgregarProveedor.addClickHandler(new ClickHandler() {
			public void onClick(ClickEvent event) {
				cargarProveedorATabla();
			}
		});
		
		layoutPanel.add(btnAgregarProveedor);
		layoutPanel.setWidgetLeftWidth(btnAgregarProveedor, 45.0, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(btnAgregarProveedor, 940.0, Unit.PX, 28.0, Unit.PX);
		
		ScrollPanel spProveedores = new ScrollPanel();
		spProveedores.setStyleName("tabla");
		layoutPanel.add(spProveedores);
		layoutPanel.setWidgetLeftWidth(spProveedores, 5.0, Unit.PCT, 90.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(spProveedores, 980.0, Unit.PX, 250.0, Unit.PX);
		
		ftProveedores = new FlexTable();
		spProveedores.setWidget(ftProveedores);
		ftProveedores.setSize("100%", "100%");
		
		//cargamos el encabezado de la tabla
		// columna de nombre
		ftProveedores.setText(0, COL_NOMBRE, "NOMBRE");
		ftProveedores.getCellFormatter().setWidth(0, COL_NOMBRE, "25%");
		
		// columna rubro
		ftProveedores.setText(0, COL_RUBRO, "RUBRO");
		ftProveedores.getCellFormatter().setWidth(0, COL_RUBRO, "20%");
				
		// columna teléfono
		ftProveedores.setText(0, COL_TELEFONO, "TELÉFONO");
		ftProveedores.getCellFormatter().setWidth(0, COL_TELEFONO, "20%");
				
		// columna mail
		ftProveedores.setText(0, COL_MAIL, "E-MAIL");
		ftProveedores.getCellFormatter().setWidth(0, COL_MAIL, "20%");
		
		// columna más información
		ftProveedores.setText(0, COL_MAS_INFO, "+ INFO");
		ftProveedores.getCellFormatter().setWidth(0, COL_MAS_INFO, "10%");
		
		// columna eliminar
		ftProveedores.setText(0, COL_ELIMINAR_PROVEEDOR, "");
		ftProveedores.getCellFormatter().setWidth(0, COL_ELIMINAR_PROVEEDOR, "5%");
		
		// seteamos el estilo a los encabezados
		ftProveedores.getRowFormatter().addStyleName(0, "tablaEncabezado");
		
		Label pie = new Label("");
		pie.setStyleName("labelTitulo");
		layoutPanel.add(pie);
		layoutPanel.setWidgetLeftWidth(pie, 5.0, Unit.PCT, 90.0, Unit.PCT);
		layoutPanel.setWidgetTopHeight(pie, 1230.0, Unit.PX, 50.0, Unit.PX);
		
		Button btnSalir = new Button();
		
		//al presionar el botón salir
		btnSalir.addClickHandler(new ClickHandler() {
			public void onClick(ClickEvent event) {
				cerrarPantalla();
			}
		});
		
		btnSalir.setText("CANCELAR");
		layoutPanel.add(btnSalir);
		layoutPanel.setWidgetRightWidth(btnSalir, 5.0, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetBottomHeight(btnSalir, 15.0, Unit.PX, 28.0, Unit.PX);
		
		btnCrearProducto = new Button();
		
		//al presionarse el botón crear producto
		btnCrearProducto.addClickHandler(new ClickHandler() {
			public void onClick(ClickEvent event) {
				
				btnCrearProducto.setEnabled(false);
				
				validarDatos();			
			}
		});
		
		btnCrearProducto.setText("CREAR");
		layoutPanel.add(btnCrearProducto);
		layoutPanel.setWidgetRightWidth(btnCrearProducto, 17.5, Unit.PCT, 10.0, Unit.PCT);
		layoutPanel.setWidgetBottomHeight(btnCrearProducto, 15.0, Unit.PX, 28.0, Unit.PX);
				
		cargarComboClase();
		
		cargarComboMateriales();
		
		cargarComboDimensiones();
		
		cargarProveedores();
	}
	
	
	/**
	 * Méetodo que carga el combobox de clases de productos.
	 */
	private void cargarComboClase()
	{		
		ingenieriaService.buscarClasesProducto(new AsyncCallback<List<ClaseProductoDTO>>(){

			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO.");
			}

			@Override
			public void onSuccess(List<ClaseProductoDTO> result) {
				clasesProducto = result;
				
				//creamos una nueva clase que representará la posible clase a crear en el combobox de clases
				ClaseProductoDTO claseProductoNueva = new ClaseProductoDTO();
				
				if(clasesProducto.size() > 0){
					//obtenemos la clase con el último código de clase generado
					ClaseProductoDTO ultimaClase = clasesProducto.get(clasesProducto.size()-1);
					claseProductoNueva.setCodigo(ultimaClase.getCodigo()+1);
				}
				
				else
					claseProductoNueva.setCodigo(1);
				
				claseProductoNueva.setNombre("NUEVA CLASE");
				
				//en el combobox, para representar la nueva clase se muestra: código clase - NUEVA CLASE 
				cbCodigoClase.addItem(claseProductoNueva.getCodigo()+ " - NUEVA CLASE");
							
				//coninuamos cargando el combobox con todas las clases de producto
				for(ClaseProductoDTO claseProducto : clasesProducto)
					cbCodigoClase.addItem(""+claseProducto.getCodigo());
				
				//agregamos la nueva clase al comiendo de la lista de clases de productos para que 
				//los índices del combobox y la lista queden vinculados
				clasesProducto.add(0, claseProductoNueva);
				
				//cargamos el nombre de la clase nueva al textbox de nombre de clase
				tbNombreClase.setText(claseProductoNueva.getNombre());
				
				//cargamos el combobox de elementos con los elementos pertenecientes a la clase seleccionada
				cargarComboElemento();
			}
			
		});
		
	}
	
	/**
	 * Método que carga el combobox de elementos de productos
	 */
	private void cargarComboElemento()
	{
		//borramos todos los items del combobox
		cbCodigoElemento.clear();
		
		//buscamos la el código de clase de producto seleccionada				
		int codigoClase = clasesProducto.get(cbCodigoClase.getSelectedIndex()).getCodigo();
		
		ingenieriaService.buscarElementosProducto(codigoClase, new AsyncCallback<List<ElementoProductoDTO>>(){

			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO.");
				
			}

			@Override
			public void onSuccess(List<ElementoProductoDTO> result) {		
				elementosProducto = result;
				
				//creamos un nuevo elemento que representará el posible elemento a crear en el combobox de elementos
				ElementoProductoDTO nuevoElemento = new ElementoProductoDTO();
				
				//si hay elementos cargados en la base de datos para la clase seleccionada
				if(elementosProducto.size() > 0){
					//obtenemos el último elemento cargado
					ElementoProductoDTO ultimoElemento = elementosProducto.get(elementosProducto.size()-1);
					
					nuevoElemento.setCodigo(ultimoElemento.getCodigo()+1);
				}
				
				//si se seleccionó una clase nueva
				else
					nuevoElemento.setCodigo(1);
					
				//recuperamos el código de clase seleccionado. Para ello obtenemos el primer elemento
				//de la lista de clases ya que siempre existirá.
				int codigoClase = clasesProducto.get(0).getCodigo();
				nuevoElemento.getClase().setCodigo(codigoClase);
				
				nuevoElemento.setNombre("NUEVO ELEMENTO");
				nuevoElemento.setTipoDimension("");
				
				//agregamos un nuevo item al combobox de códigos de elementos
				cbCodigoElemento.addItem(nuevoElemento.getCodigo() + " - NUEVO ELEMENTO");
				
				for(ElementoProductoDTO elementoProducto : elementosProducto)
					cbCodigoElemento.addItem(""+elementoProducto.getCodigo());
				
				//agregamos el nuevo elemento en la primera posición de la lista de elementos para
				//que nos quede vinculados los index con el combobox
				elementosProducto.add(0, nuevoElemento);
				
				//cargamos el texbox de nombre de elemento con el nuevo elemento cargado
				tbNombreElemento.setText(nuevoElemento.getNombre());
				tbNombreElemento.setEnabled(true);
			}
			
		});
	}
	
	/**
	 * método que carga el combobox de materiales de producto
	 */
	private void cargarComboMateriales()
	{
		ingenieriaService.buscarMaterialesProducto(new AsyncCallback<List<MaterialProductoDTO>>()
		{

			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO.");
				
			}

			@Override
			public void onSuccess(List<MaterialProductoDTO> result) {
				materialesProducto = result;
				
				//creamos un nuevo material de producto que representará el posible material a cargar
				MaterialProductoDTO nuevoMaterial = new MaterialProductoDTO();
				
				//si hay materiales cargados en la base datos
				if(materialesProducto.size() > 0)
				{
					//buscamos el último material cargado y seteamos el código del material al nuevo material
					MaterialProductoDTO ultimoMaterial = materialesProducto.get(materialesProducto.size()-1);
					nuevoMaterial.setCodigo(ultimoMaterial.getCodigo() + 1);
				}
				
				//si no hay materiales cargados en la base de datos
				else
					nuevoMaterial.setCodigo(1);
				
				nuevoMaterial.setNombre("NUEVO MATERIAL");
				
				//agregamos el nuevo material al combobox de código de materiales
				cbCodigoMaterial.addItem(nuevoMaterial.getCodigo() + " - NUEVO MATERIAL");
				
				for(MaterialProductoDTO materialProducto : materialesProducto)
					cbCodigoMaterial.addItem(""+materialProducto.getCodigo());					
				
				//agregamos el nuevo materiales en la primera posicion de la lista de materiales para que queden vinculados los
				//index con el combobox de códigos 
				materialesProducto.add(0, nuevoMaterial);
				
				//seteamos el nombre de material con el del nuevo material
				tbNombreMaterial.setText(nuevoMaterial.getNombre());
				tbNombreMaterial.setEnabled(true);
			}
	
		});
	}
	
	/**
	 * Método que carga el combobox de dimensiones con las posibles dimensiones de producto
	 */
	private void cargarComboDimensiones()
	{
		cbDimension.addItem("UNIDAD");
		cbDimension.addItem("LONGITUD");
		cbDimension.addItem("SUPERFICIE");
		
		tbMedidaVariable2.setEnabled(false);
	}
	
	/**
	 * Método que carga el combobox de proveedores con los proveedores cargados en la base de datos
	 */
	private void cargarProveedores()
	{
		
		ComprasServiceAsync comprasService = GWT.create(ComprasService.class);
				
		//buscamos los proveedores en la base de datos
		comprasService.buscarNombresProveedores(new AsyncCallback<List<String>>(){

			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO.");				
			}

			@Override
			public void onSuccess(List<String> result) {
				nombresProveedores = result;

				//cargamos el combobox proveedores con la lista de proveedores
				for(String nombreProveedor : nombresProveedores)
					cbProveedor.addItem(nombreProveedor);
			}
			
		});
	}
	
	
	/**
	 * Método que carga en la tabla de medidas una nueva medida variable
	 */
	private void cargarMedidaATabla()
	{
		float medida1 = 0;
		float medida2 = 0;
		
		boolean error = false;
		
		//validamos las medidas del producto
		if(tbMedidaVariable1.getText().equals("")){
			Window.alert("- Complete todos los campos de la medida del producto.");
			error = true;
		}
		
		else if(tbMedidaVariable2.getText().equals("") && tbMedidaVariable2.isEnabled()){
			Window.alert("- Complete todos los campos de la medida del producto.");
			error = true;
		}
				
		if(!error){
			try{
				medida1 = Float.parseFloat(tbMedidaVariable1.getText());
						
				//si la medida1 es menor o igual que cero
				if(medida1 <= 0)
					throw new Exception();
				
				//si es una medida de dos dimensiones
				if(tbMedidaVariable2.isEnabled()){
					medida2 = Float.parseFloat(tbMedidaVariable2.getText());
					
					//si la medida2 es menor o igual que cero
					if(medida2 <= 0)
						throw new Exception();
				}
				
				MedidaVariableEstandarDTO medida = new MedidaVariableEstandarDTO();
				
				medida.setMedidaVariable1(medida1);
				medida.setMedidaVariable2(medida2);
				
				int i = 0;
				boolean encontrado = false;
				
				while(i < medidas.size() && !encontrado)
				{
					if(medidas.get(i).getMedidaVariable1() == medida1 && medidas.get(i).getMedidaVariable2() == medida2)
						encontrado = true;
					
					i++;
				}
				
				//si la medida no está en la tabla, agregamos la medida
				if(!encontrado)
				{
					// cargamos el producto a la tabla
					int numeroFila = ftMedidas.getRowCount();
					
					// columna medida 1
					ftMedidas.setWidget(numeroFila, COL_MEDIDA_1, new Label(String.valueOf(medida.getMedidaVariable1())));
					ftMedidas.getCellFormatter().setWordWrap(numeroFila, COL_MEDIDA_1, true);

					// columna medida 2
					ftMedidas.setWidget(numeroFila, COL_MEDIDA_2, new Label(String.valueOf(medida.getMedidaVariable2())));
					ftMedidas.getCellFormatter().setWordWrap(numeroFila, COL_MEDIDA_2, true);

					//creamos un label que muestra una cruz roja
					Label lblEliminar = new Label("");
					lblEliminar.setSize("16px", "16px");
					lblEliminar.setStyleName("labelBorrar");
					
					lblEliminar.addClickHandler(new ClickHandler() {
						public void onClick(ClickEvent event) {
							int filaSeleccionada = ftMedidas.getCellForEvent(event).getRowIndex();
						
							eliminarMedidaDeTabla(filaSeleccionada); 
						}
					});
									
					//columna eliminar
					ftMedidas.setWidget(numeroFila, COL_ELIMINAR_MEDIDA, lblEliminar);
					ftMedidas.getFlexCellFormatter().setHorizontalAlignment(numeroFila, COL_ELIMINAR_MEDIDA, HasHorizontalAlignment.ALIGN_CENTER);
					
					//seteamos el estilo de renglón de tabla
					ftMedidas.getRowFormatter().setStyleName(numeroFila, "tablaRenglon");
					
					//agregamos la medida a la lista de medidas
					medidas.add(medida);
					
					//limpiamos los campos de texto
					tbMedidaVariable1.setText("");
					tbMedidaVariable2.setText("");
					
					//inhabilitamos el combobox dimensión
					cbDimension.setEnabled(false);
				}
				
				//si ya se agregó la medida a la tabla
				else
					Window.alert("La medida ya ha sido incluída en la tabla de medidas.");
			}
			
			catch(Exception e)
			{
				Window.alert("- La medida variable del producto debeser ser un número mayor que cero.");				
			}
		}
	}
	
	/**
	 * Método que borra una fila de la tabla de medidas
	 * @param filaSeleccionada. Fila a borrar.
	 */
	private void eliminarMedidaDeTabla(int filaSeleccionada)
	{	
		//eliminamos la fila de la tabla
		ftMedidas.removeRow(filaSeleccionada);
		
		//se borra la medida de la lista de medidas.
		//se resta 1 a la fila seleccionada porque la fila 0 es el encabezado
		medidas.remove(filaSeleccionada-1);
		
		//habilitamos el combobox de dimesión
		if(ftMedidas.getRowCount() == 1)
			cbDimension.setEnabled(true);
	}
	
	/**
	 * Método que carga un proveedor en la tabla de proveedores
	 */
	private void cargarProveedorATabla()
	{
		//obtenemos el nombre del proveedor seleccionado
		String proveedorSeleccionado = cbProveedor.getValue(cbProveedor.getSelectedIndex());
		
		//verificamos que no se cargue en la tabla dos veces el mismo proveedor
		int i = 0;
		boolean encontrado = false;
		
		while(i < proveedores.size() && !encontrado)
		{
			if(proveedores.get(i).getNombre().equals(proveedorSeleccionado))
				encontrado = true;
			
			i++;
		}
		
		
		//si el proveedor no está en la tabla de proveedores
		if(!encontrado){
		
			//buscamos los datos del proveedor necesarios para cargar la tabla
			ingenieriaService.buscarProveedor(proveedorSeleccionado, new AsyncCallback<ProveedorDTO>(){

				@Override
				public void onFailure(Throwable caught) {
					Window.alert("ERROR EN EL SERVICIO."); 
					
				}

				@Override
				public void onSuccess(ProveedorDTO result) {
					ProveedorDTO proveedor = result;
					
					// cargamos el producto a la tabla
					int numeroFila = ftProveedores.getRowCount();		
					
					//columna nombre
					ftProveedores.setWidget(numeroFila, COL_NOMBRE, new Label(proveedor.getNombre()));
					ftProveedores.getCellFormatter().setWordWrap(numeroFila, COL_NOMBRE, true);
					
					// columna rubro
					ftProveedores.setWidget(numeroFila, COL_RUBRO, new Label(proveedor.getRubro()));
					ftProveedores.getCellFormatter().setWordWrap(numeroFila, COL_RUBRO, true);

					// columna teléfono
					ftProveedores.setWidget(numeroFila, COL_TELEFONO, new Label(proveedor.getTelefono()));
					ftProveedores.getCellFormatter().setWordWrap(numeroFila, COL_TELEFONO, true);

					// columna mail
					ftProveedores.setWidget(numeroFila, COL_MAIL, new Label(proveedor.getMail()));
					ftProveedores.getCellFormatter().setWordWrap(numeroFila, COL_MAIL, true);

					// imagen más información
					Label info = new Label("");
					info.setSize("16px", "16px");
					info.setStyleName("labelInfo");	
					
					//cuando se presiona "más información"
					info.addClickHandler(new ClickHandler() {
						public void onClick(ClickEvent event) {
							
							//obtenemos la celda en donde se hizo click
							Cell celda = ftProveedores.getCellForEvent(event);
							
							//obtenemos el nombre del proveedor. Restamos 1 al row index porque la fila 1 es el encabezado
							String nombreProveedor = proveedores.get(celda.getRowIndex() - 1).getNombre();
							
							cargarMasInformacionProveedor(nombreProveedor);
						}
					});
					
					// columna más información
					ftProveedores.setWidget(numeroFila, COL_MAS_INFO, info);
					ftProveedores.getFlexCellFormatter().setHorizontalAlignment(numeroFila, COL_MAS_INFO, HasHorizontalAlignment.ALIGN_CENTER);
					
					//creamos un label que muestra una cruz roja
					Label lblEliminar = new Label("");
					lblEliminar.setSize("16px", "16px");
					lblEliminar.setStyleName("labelBorrar");
					
					lblEliminar.addClickHandler(new ClickHandler() {
						public void onClick(ClickEvent event) {
							int filaSeleccionada = ftProveedores.getCellForEvent(event).getRowIndex();
						
							eliminarProveedorDeTabla(filaSeleccionada); 
						}
					});
									
					//columna eliminar
					ftProveedores.setWidget(numeroFila, COL_ELIMINAR_PROVEEDOR, lblEliminar);
					ftProveedores.getFlexCellFormatter().setHorizontalAlignment(numeroFila, COL_ELIMINAR_PROVEEDOR, HasHorizontalAlignment.ALIGN_CENTER);
					
					//seteamos el estilo de renglón de tabla
					ftProveedores.getRowFormatter().setStyleName(numeroFila, "tablaRenglon");
					
					//agregamos el proveedor a la lista de proveedores
					proveedores.add(proveedor);
				}
				
			});
		}
		
		//si ya se había cargado el proveedor con anterioridad
		else
			Window.alert("El proveedor ya ha sido incluído en la tabla de proveedores.");
	}
	
	
	/**
	 * Método que borra una fila de la tabla de proveedores
	 * @param filaSeleccionada. Fila a borrar.
	 */
	private void eliminarProveedorDeTabla(int filaSeleccionada)
	{	
		//eliminamos la fila de la tabla
		ftProveedores.removeRow(filaSeleccionada);
		
		//se borra el proveedor de la lista de proveedores.
		//se resta 1 a la fila seleccionada porque la fila 0 es el encabezado
		proveedores.remove(filaSeleccionada-1);										
	}
	
	
	/**
	 * Método que validar los datos cargados para crear el producto
	 */
	private void validarDatos()
	{
		List<String> errores = new LinkedList<String>();
		String mensaje = "";
		
		//validamos el nombre de clase
		if(tbNombreClase.getText().equals(""))
			errores.add("- El nombre de clase no puede ser vacío.");
		
		//validamos el nombre del elemenot
		if(tbNombreElemento.getText().equals(""))
			errores.add("- El nombre del elemento no puede ser vacío.");
		
		//validamos el nombre del material
		if(tbNombreMaterial.getText().equals(""))
			errores.add("- El nombre del material no puede ser vacío.");
		
		if(tbMedidaFija.getText().equals(""))
			errores.add("- La medida fija del producto no puede ser vacía.");
			
		if(medidas.size() == 0)
			errores.add("- Agregue al menos una medida variable estándar al producto.");
			
		
		//si hubo errores, armamos el mensaje de error
		if(errores.size() > 0){
			mensaje = mensaje + errores.get(0);
			
			for(int i=1; i<errores.size(); i++)
				mensaje = mensaje + '\n' + '\n' + errores.get(i);
			
			Window.alert(mensaje);
			btnCrearProducto.setEnabled(true);
		}
			
		else
		{
			guardarProducto();			
		}
	}
	
	
	/**
	 * Método que guarda un producto con los datos ingrsados
	 */
	private void guardarProducto()
	{
		ProductoDTO producto = new ProductoDTO();
				
		//cargamos los datos correspondientes a la clase
		ClaseProductoDTO clase = new ClaseProductoDTO();	
		
		//El primer elemento del combobox no contiene un id limpio, sino que además tiene el string "NUEVA CLASE".
		if(cbCodigoClase.getSelectedIndex() != 0){
			
			//obtenemos el código de clase del combobox
			int codigoClase = Integer.parseInt(cbCodigoClase.getValue(cbCodigoClase.getSelectedIndex()));
			
			clase.setCodigo(codigoClase);
		}
		
		//si se seleecionó el primer ítem se trata de una clase nueva
		else
			clase.setCodigo(0);
		
		clase.setNombre(tbNombreClase.getText());
		
		
		
		//cargamos los correspondientes al elemento
		ElementoProductoDTO elemento = new ElementoProductoDTO();
		
		//El primer elemento del combobox no contiene un id limpio, sino que además tiene el string "NUEVO ELEMENTO".
		if(cbCodigoElemento.getSelectedIndex() != 0)
		{
			//obtenemos el código de elemento del combobox
			int codigoElemento = Integer.parseInt(cbCodigoElemento.getValue(cbCodigoElemento.getSelectedIndex()));
			
			elemento.setCodigo(codigoElemento);
		}
		
		//si se seleecionó el primer ítem se trata de un nuevo elemento
		else	
			elemento.setCodigo(elementosProducto.get(0).getCodigo());
		
		elemento.setNombre(tbNombreElemento.getText());
		elemento.setClase(clase);
		
		//recuperamos la dimensión seleccionada y se la seteamos al elemento
		String dimension = cbDimension.getValue(cbDimension.getSelectedIndex());
		elemento.setTipoDimension(dimension);
		
		//asignamos el elemento al producto
		producto.setElemento(elemento);
		
		
		
		//cargamos los datos correspondientes al material
		MaterialProductoDTO material = new MaterialProductoDTO();
		
		//El primer elemento del combobox no contiene un id limpio, sino que además tiene el string "NUEVO MATERIAL".
		if(cbCodigoMaterial.getSelectedIndex() != 0)
		{
			//obtenemos el código de material del combobox
			int codigoMaterial = Integer.parseInt(cbCodigoMaterial.getValue(cbCodigoMaterial.getSelectedIndex()));
			
			material.setCodigo(codigoMaterial);
		}
		
		//si se seleecionó el primer ítem se trata de un nuevo material
		else
			material.setCodigo(0);
		
		material.setNombre(tbNombreMaterial.getValue());
		
		//asignamos el material al producto
		producto.setMaterial(material);
		
		
		//cargamos los datos de la medida fija
		MedidaFijaProductoDTO medidaFija = new MedidaFijaProductoDTO();
		medidaFija.setMedida(tbMedidaFija.getText());
		
		//cargamos los datos del producto
		producto.setMedidaFija(medidaFija);
		producto.setMedidasEstandar(medidas);
		producto.setActivo(true);
		
		ingenieriaService.registrarProducto(producto, new AsyncCallback<Integer>(){

			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO" + '\n' + '\n' + caught.getMessage());
				btnCrearProducto.setEnabled(true);				
			}

			@Override
			public void onSuccess(Integer result) {
				guardarMedidasVariablesEstandar(result);
			}});
	}
	
	
	
	/**
	 * Método que guarda todas las medidas estándar cargadas en la tabla
	 * @param idProducto. Es el id del producto al que pertenecen las medidas estándar
	 */
	private void guardarMedidasVariablesEstandar(final int idProducto)
	{
		ingenieriaService.registrarMedidasVariablesEstandar(idProducto, medidas, new AsyncCallback<Boolean>()
		{
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO" + '\n' + '\n' + caught.getMessage());
				btnCrearProducto.setEnabled(true);				
			}

			@Override
			public void onSuccess(Boolean result) {
				guardarInventario(idProducto);		
			}
	
		});		
	}
	
	/**
	 * Método que crea un registro del inventario del producto en la base de datos
	 * @param idProducto. Id del producto para el cual se crea el inventario.
	 */
	private void guardarInventario(final int idProducto)
	{
		ingenieriaService.registrarInventario(idProducto, medidas, new AsyncCallback<Boolean>()
		{
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO" + '\n' + '\n' + caught.getMessage());
				btnCrearProducto.setEnabled(true);				
			}

			@Override
			public void onSuccess(Boolean result) {
				guardarProveedoresProducto(idProducto);		
			}
	
		});		
	}
	
	/**
	 * Método que guarda en la base de datos los proveedores del producto
	 * @param idProducto. Es el id del producto que se está creando. Ya se conoce su id porque a esta
	 * altura el producto está cargado en la base de datos.
	 */
	private void guardarProveedoresProducto(int idProducto)
	{
		ingenieriaService.registrarProveedorDeProducto(idProducto, proveedores, new AsyncCallback<Boolean>()
		{
			@Override
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO" + '\n' + '\n' + caught.getMessage());
				btnCrearProducto.setEnabled(true);
			}

			@Override
			public void onSuccess(Boolean result) {
				Window.alert("El producto se registró correctamente");

				cerrarPantalla();
			}			
		});		
	}
	
	/**
	 * Método que busca toda la información de un proveedor y lo muesta en un popup
	 * @param nombreProveedor. Nombre del proveedor a buscar.
	 */
	private void cargarMasInformacionProveedor(String nombreProveedor)
	{
		ingenieriaService.buscarProveedorCompleto(nombreProveedor, new AsyncCallback<ProveedorDTO>(){
			
			public void onFailure(Throwable caught) {
				Window.alert("ERROR EN EL SERVICIO");
			}

			@Override
			public void onSuccess(ProveedorDTO result) {

				ProveedorDTO proveedor = result;
				
				//creamos el popup "más información" de proveedor
				final P_DetalleProveedor popUpMasInfo = new P_DetalleProveedor(proveedor);
				
				//seteamos sus propiedades y la mostramos en pantalla
				popUpMasInfo.setGlassEnabled(true);
				popUpMasInfo.center();
				popUpMasInfo.show();							
			}
		});
		
	}
	
	
	/**
	 * Método que cierra la pantalla de alta de producto
	 */
	private void cerrarPantalla()
	{
		tbPadre.remove(Validaciones.numeroElemento(tbPadre, "CREAR PRODUCTO"));				
	}
}
